/**
 * 后端地址智能检测工具
 * 自动检测可用的后端服务器地址
 */

interface BackendConfig {
  apiUrl: string
  wsUrl: string
}

// 候选后端地址列表
const getCandidateUrls = (): string[] => {
  const hostname = window.location.hostname
  const protocol = window.location.protocol
  
  const candidates: string[] = []
  
  // 1. 环境变量配置（最高优先级）
  const envApiUrl = import.meta.env.VITE_API_BASE_URL
  if (envApiUrl && envApiUrl.trim()) {
    candidates.push(envApiUrl.trim())
  }
  
  // 2. localhost特殊处理
  if (hostname === 'localhost' || hostname === '127.0.0.1') {
    candidates.push('http://localhost:8000')
    return candidates
  }
  
  // 3. 同主机同端口（最常见情况）
  candidates.push(`${protocol}//${hostname}:8000`)
  
  // 4. 如果是通过代理访问，尝试一些常见的后端地址
  if (hostname.startsWith('192.168.') || hostname.startsWith('10.') || hostname.startsWith('172.')) {
    // 尝试同网段的常见服务器地址
    const parts = hostname.split('.')
    if (parts.length === 4) {
      // 尝试 .200, .100, .1 等常见服务器地址
      const baseNetwork = `${parts[0]}.${parts[1]}.${parts[2]}`
      const commonHosts = ['200', '100', '1', '10', '50']
      
      for (const host of commonHosts) {
        if (host !== parts[3]) { // 不重复添加当前主机
          candidates.push(`${protocol}//${baseNetwork}.${host}:8000`)
        }
      }
    }
  }
  
  return candidates
}

// 测试后端地址是否可用
const testBackendUrl = async (url: string): Promise<boolean> => {
  try {
    const controller = new AbortController()
    const timeoutId = setTimeout(() => controller.abort(), 3000) // 3秒超时
    
    const response = await fetch(`${url}/api/`, {
      method: 'GET',
      signal: controller.signal,
      mode: 'cors'
    })
    
    clearTimeout(timeoutId)
    return response.ok
  } catch (error) {
    return false
  }
}

// 检测可用的后端地址
export const detectBackendUrl = async (): Promise<BackendConfig> => {
  const candidates = getCandidateUrls()
  
  console.log('🔍 开始检测后端地址...', candidates)
  
  // 并行测试所有候选地址
  const testPromises = candidates.map(async (url) => {
    const isAvailable = await testBackendUrl(url)
    return { url, isAvailable }
  })
  
  const results = await Promise.all(testPromises)
  
  // 找到第一个可用的地址
  for (const result of results) {
    if (result.isAvailable) {
      const apiUrl = result.url
      const wsUrl = apiUrl.replace(/^http/, 'ws')
      
      console.log('✅ 检测到可用后端地址:', apiUrl)
      
      return {
        apiUrl,
        wsUrl
      }
    }
  }
  
  // 如果都不可用，返回默认地址
  const defaultUrl = candidates[0] || `${window.location.protocol}//${window.location.hostname}:8000`
  const wsUrl = defaultUrl.replace(/^http/, 'ws')
  
  console.warn('⚠️ 未检测到可用后端，使用默认地址:', defaultUrl)
  
  return {
    apiUrl: defaultUrl,
    wsUrl
  }
}

// 缓存检测结果
let cachedConfig: BackendConfig | null = null

export const getBackendConfig = async (): Promise<BackendConfig> => {
  if (!cachedConfig) {
    cachedConfig = await detectBackendUrl()
  }
  return cachedConfig
}

// 重新检测（用于手动刷新）
export const refreshBackendConfig = async (): Promise<BackendConfig> => {
  cachedConfig = null
  return await getBackendConfig()
}
